home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Kernel / KmdOps / emtrace.c next >
Encoding:
C/C++ Source or Header  |  1990-08-30  |  10.2 KB  |  415 lines
  1.  
  2. /*  C O P Y R I G H T   N O T I C E :                                     */
  3. /* Copyright 1986 Eric Jul.  May not be used for any               */
  4. /* purpose without written permission from the author.              */
  5.  
  6.  
  7. /*
  8.  * $Header$
  9.  * INTERFACE:    Takes KMD parameters, see error msg.
  10.  *
  11.  * FUNCTION:    Execute single KMD trace requests.
  12.  *
  13.  * IMPORTS:    loads, see #include
  14.  *
  15.  * EXPORTS:    Nothing.
  16.  *
  17.  * DESIGN:    Send start trace message to the traced process and then
  18.  *              repeatedly receive and print data until stop trace
  19.  *              message arrives.
  20.  *
  21.  */
  22. #undef integer
  23. #include <sys/types.h>
  24. #include <sys/socket.h>
  25. #include <netinet/in.h>
  26. #include <stdio.h>
  27.  
  28. #define mSUCCESS(X) (((X) & 7) == 1)
  29.  
  30. typedef int KKStatus;
  31.  
  32. #define MAXMESSAGESIZE        1000
  33. #include "Kernel/h/stdTypes.h"
  34. #include "Kernel/h/kmdDefs.h"
  35. #include "Kernel/h/emPorts.h"
  36. #include <netdb.h>
  37. #include <signal.h>
  38.  
  39. #define endcase break
  40.  
  41. int                  talkSock;
  42. struct sockaddr_in   destSockDescr = {AF_INET};
  43. int                  prodTime = 1;
  44. int                 tracing = 0;
  45. char                *tracename;
  46. int                 machineNameGiven = 0;
  47. char                *machineName;
  48. int                 OK;
  49. static int          pid = 0;
  50. static int          pidGiven = 0;
  51. int                 MType, MInt;
  52. char                MString[5000];
  53.  
  54. /* Define signal handlers */
  55.  
  56. void PipeHandler(sig)
  57. int sig;
  58. {
  59.     printf("SIGPIPE>>> The connection to the process broke.\n");
  60.     printf("Terminating\n");
  61.     exit(sig);
  62. }
  63.  
  64. void TerminationHandler(sig)
  65. int sig;
  66. { 
  67.     if (sig != 0) {
  68.     printf("Terminating trace due to signal %d.\n", sig);
  69.     }
  70.     KMDSend(talkSock, KMDCLASTMSG, 0, "done");
  71.     shutdown(talkSock, 1);
  72.     while(mSUCCESS(KMDReceive(talkSock, &MType, &MInt, MString)));
  73.     close(talkSock);
  74.     exit(sig);
  75. };
  76.  
  77.  
  78. void Prodder()
  79. /* Prods the kernel by sending a SIGURG signal.
  80.    Exponential backoff.
  81.  */
  82. {
  83. /*    kill(pid, SIGURG); */
  84.     prodTime += prodTime;
  85.     alarm(prodTime);
  86. }
  87.  
  88. void SendTraceStart(fTraceName, fTraceLevel, fUseStdOut)
  89. char    *fTraceName;
  90. int     fTraceLevel;
  91. int     fUseStdOut;
  92. {
  93.     KKStatus kstat;    
  94.     if (fUseStdOut) {
  95.     kstat = KMDSend(talkSock, KMDCTRACESTDOUT, fTraceLevel, fTraceName);
  96.     } else {
  97.     kstat = KMDSend(talkSock, KMDCTRACE, fTraceLevel, fTraceName);
  98.     }
  99.     
  100.     if (! mSUCCESS( kstat ) ) {
  101.         printf("Send start trace msg failure, kstat = 0x%08x\n", kstat);
  102.     perror("send");
  103.         exit(1);
  104.     };
  105.  
  106. }
  107.  
  108. void SendTraceStop(fTraceName, fTraceLevel, fUseStdOut)
  109. char    *fTraceName;
  110. int     fTraceLevel;
  111. int     fUseStdOut;
  112. {
  113.     KKStatus kstat;    
  114.     if (fUseStdOut) {
  115.     kstat = KMDSend(talkSock, KMDCUNTRACESTDOUT, fTraceLevel, fTraceName);
  116.     } else {
  117.     kstat = KMDSend(talkSock, KMDCUNTRACE, fTraceLevel, fTraceName);
  118.     }
  119.     
  120.     if (! mSUCCESS( kstat ) ) {
  121.         printf("Send stop trace msg failed, kstat = 0x%08x\n", kstat);
  122.     perror("send");
  123.         exit(1);
  124.     };
  125. }
  126.  
  127. main(argc, argv)
  128. int         argc;
  129. char        *argv[];
  130. {
  131.   int               OK;
  132.   char              EPName[50];
  133.   static int        i, EPLNN, Level;
  134.   KKStatus          kstat;
  135.   static char       StdTrace[] = "DebugMsg";
  136.   char              myHostName[100];
  137.   struct hostent   *myHost;
  138.   int               machineNameGiven = 0;
  139.   int               argCount = argc;
  140.   
  141.     tracename = StdTrace;           /* default */
  142.     Level = 3;                      /* default */
  143.     
  144.     if (argc == 2)
  145.         if (!strcmp(argv[1], "usage")) {
  146.         printf("Usage: trace <options>\n");
  147.                 printf("    -T <name>\tStart tracing\n");
  148.                 printf("    -S <name>\tStart the trace; output to kernel stdout\n");
  149.                 printf("             \t(to stop, use -C in a later call)\n");
  150.         printf("    -l <level>\tSet the trace level for -S & -T\n");
  151.         printf("              \t(must preceed -T and -S)\n");
  152.         printf("    -M <name> \tTrace kernel on the named machine\n");
  153.         printf("    -m <name> \tTrace kernel on the named machine\n");
  154.         printf("    -x [<level>]\tDebugMsg trace\n");
  155.         printf("    -t [<level>]\tMMTrace\n");
  156.                 printf("The program waits until it or the kernel dies.\n");
  157.         exit(0);
  158.         }
  159.  
  160.     /*
  161.      * Parse command line options
  162.      */
  163.     while (argc > 1 && argv[1][0] == '-') {
  164.         switch (argv[1][1]) {
  165.         case 'N':        /* Set logical node number */
  166.             if (argv[1][2] == '\0') {
  167.                 EPLNN = atoi(argv[2]);
  168.                 argc--;
  169.                 argv++;
  170.             } else
  171.                 EPLNN = atoi(&argv[1][2]);
  172.                         
  173.             break;
  174.         case 'x':
  175.                 case 'n':
  176.                 case 'C':
  177.         case 't':
  178.         case 'l':
  179.                 case 'T':
  180.                 case 'S':
  181.             if (argv[1][2] == '\0') {
  182.                 argc--;
  183.                 argv++;
  184.             }
  185.             break;
  186.         case 'P':       /* Set pid, cancel LNN usage. */
  187.             if (argv[1][2] == '\0') {
  188.                 pid = atoi(argv[2]);
  189.                 argc--;
  190.                 argv++;
  191.             } else
  192.                 pid = atoi(&argv[1][2]);
  193.                         pidGiven = 1;
  194.             printf("warning: -P ignored.\n");
  195.             break;
  196.                 case 'M':
  197.                 case 'm':
  198.                         if (argv[1][2] == '\0') {
  199.                 strcpy(myHostName, argv[2]);
  200.                 argc--;
  201.                 argv++;
  202.             } else strcpy(myHostName, &argv[1][2]);
  203.             machineNameGiven ++;
  204.                         break;
  205.    
  206.                 default:
  207.                         printf("Warning: Unknown option: %c ignored.\n",
  208.                 argv[1][1]);
  209.                         break;
  210.  
  211.         }
  212.         argc--;
  213.         argv++;
  214.     }
  215.     argv -= (argCount - argc);  /* restore for next pass */
  216.     argc = argCount;
  217.     
  218.     /* Set termination handler. */
  219.     signal(SIGHUP, TerminationHandler);
  220.     signal(SIGQUIT, TerminationHandler);
  221.     signal(SIGINT, TerminationHandler);
  222.     signal(SIGBUS, TerminationHandler);
  223.     signal(SIGSEGV, TerminationHandler);
  224.     signal(SIGTERM, TerminationHandler);
  225.     
  226.     signal(SIGPIPE, PipeHandler);
  227.     signal(SIGALRM, Prodder);
  228.     
  229.     talkSock = socket(AF_INET, SOCK_STREAM, 0, 0);
  230.     if (talkSock < 0) {
  231.                 perror("trace: socket");
  232.                 exit(1);
  233.     }
  234.  
  235.     if (! machineNameGiven) {
  236.     if (gethostname(myHostName, 100) < 0) {
  237.         perror("trace: gethostname");
  238.         exit(1);
  239.     }
  240.     }
  241.     myHost = gethostbyname(myHostName);
  242.     if (myHost == NULL) {
  243.             perror("trace: gethostbyname");
  244.             exit(1);
  245.     }
  246.  
  247.     bcopy(myHost->h_addr, &destSockDescr.sin_addr, myHost->h_length);
  248.  
  249.     {
  250.       char *emplanename;
  251.       int emPlane = 0;
  252.       int emPort = EMKERNELDEFAULTPORTNUMBER;
  253.       struct servent   *myService;
  254.       emplanename = (char *) getenv("EMPLANE");
  255.       if (emplanename != NULL) emPlane = atoi(emplanename);
  256. #ifdef DIKU
  257.       myService = getservbyname(EMKERNELSERVICEPORT, "tcp");
  258.       if(myService)
  259.     emPort = ntohs(myService->s_port);
  260. #endif
  261.       destSockDescr.sin_port = htons(emPort + emPlane*4 + 1);
  262.     }
  263.  
  264.     if (connect(talkSock, &destSockDescr, sizeof(destSockDescr)) == -1) {
  265.                 perror("trace: connect");
  266.                 exit(1);
  267.     }
  268.  
  269.  
  270.     if ( KMDTest )
  271.         printf("Connected to %d\n", ntohs(destSockDescr.sin_port));
  272.     
  273.     if (!mSUCCESS(KMDReceive(talkSock, &MType, &MInt, MString))) {
  274.         printf("Connection reply failed.\n");
  275.     TerminationHandler(0);
  276.     }
  277.     printf("%s", MString);
  278.     /* Start trace/*/
  279.     /*
  280.      * Parse command line options again.
  281.      */
  282.     while (argc > 1 && argv[1][0] == '-') {
  283.         switch (argv[1][1]) {
  284.         case 'N':        /* Set logical node number */
  285.             if (argv[1][2] == '\0') {
  286.                 argc--;
  287.                 argv++;
  288.             };                        
  289.             break;
  290.         case 'x':
  291.                         tracename = "DebugMsg";
  292.             if (argv[1][2] == '\0') {
  293.                 Level = atoi(argv[2]);
  294.                 argc--;
  295.                 argv++;
  296.             } else
  297.                 Level = atoi(&argv[1][2]);
  298.                         SendTraceStart(tracename, Level, FALSE);
  299.             break;
  300.         case 't':
  301.             if (argv[1][2] == '\0') {
  302.                 Level = atoi(argv[2]);
  303.                                 tracename = "MMTraceMsg";
  304.                 argc--;
  305.                 argv++;
  306.             } else {
  307.                                 tracename = "MMTraceMsg";
  308.                 Level = atoi(&argv[1][2]);
  309.             }
  310.                         SendTraceStart(tracename, Level, FALSE);
  311.             break;
  312.         case 'l':
  313.             if (argv[1][2] == '\0') {
  314.                 Level = atoi(argv[2]);
  315.                 argc--;
  316.                 argv++;
  317.             } else
  318.                 Level = atoi(&argv[1][2]);
  319.             break;
  320.                 case 'n':
  321.                 case 'T':
  322.                         if (argv[1][2] == '\0') {
  323.                 SendTraceStart(argv[2], Level, FALSE);
  324.                 argc--;
  325.                 argv++;
  326.             } else SendTraceStart(&argv[1][2], Level, FALSE);
  327.                         break;
  328.                 case 'S':
  329.                         if (argv[1][2] == '\0') {
  330.                 SendTraceStart(argv[2], Level, TRUE);
  331.                 argc--;
  332.                 argv++;
  333.             } else SendTraceStart(&argv[1][2], Level, TRUE);
  334.                         break;
  335.                 case 'C':
  336.                         if (argv[1][2] == '\0') {
  337.                 SendTraceStop(argv[2], Level, TRUE);
  338.                 argc--;
  339.                 argv++;
  340.             } else SendTraceStop(&argv[1][2], Level, TRUE);
  341.                         break;
  342.  
  343.         case 'P':       /* Set pid, cancel LNN usage. */
  344.             if (argv[1][2] == '\0') {
  345.                 argc--;
  346.                 argv++;
  347.             }
  348.             break;
  349.                 case 'M':
  350.                 case 'm':
  351.             if (argv[1][2] == '\0') {
  352.                 argc--;
  353.                 argv++;
  354.             }
  355.                         break;
  356.                 default:
  357.                         break;
  358.  
  359.         }
  360.         argc--;
  361.         argv++;
  362.     }
  363.     tracing = 1;
  364.     
  365.     fflush(stdout);
  366.     OK = 1;
  367.     while (OK==1) {
  368.     if (!mSUCCESS(KMDReceive(talkSock, &MType, &MInt, MString))) {
  369.         /* Something went wrong, so quit */
  370.         printf("Trace closed\n");
  371.         TerminationHandler(0);
  372.     }
  373.         if ( KMDTest ) {
  374.             printf("Msg from: %d, (%d, %d, %s)\n", talkSock,
  375.                 MType, MInt, MString);
  376.             fflush(stdout);
  377.         };
  378.         
  379.         switch ( MType ) {
  380.         
  381.         case KMDCDATA:
  382.             printf("%s", MString);
  383.             fflush(stdout);
  384.         endcase;
  385.         
  386.     case KMDREADLINE:
  387.         {
  388.         char foo[256];
  389.         printf("(edb) ");
  390.         gets(foo);
  391.         KMDSend(talkSock, KMDREADLINEANS, 0, foo);        
  392.         }
  393.     endcase;
  394.     
  395.         case KMDCUNTRACE:
  396.             OK = 0;         /* quit */
  397.         endcase;
  398.         
  399.         case KMDCERRMSG:
  400.             printf("Error: %s\n", MString);
  401.             fflush(stdout);
  402.             TerminationHandler(0);
  403.             OK = 0;         /* quit */
  404.         endcase;
  405.         
  406.         case KMDCLASTMSG:
  407.             printf("%s", MString);
  408.             TerminationHandler(0);
  409.         default:
  410.             printf("**** KMD error: Warning, bad msgtype: %d \n", MType);
  411.         };
  412.     };
  413.     TerminationHandler(0);
  414. }
  415.